import rolesData from '@/static/roles.json'

// 导入角色服务
import roleService from '@/utils/roleService.js'

// 角色管理类
class RoleManager {
  constructor() {
    // 初始化角色信息
    this.initRoles();
    // 标记是否已从线上获取过角色
    this.hasInitializedOnlineRoles = false;
    // 新增标记：是否正在初始化中
    this.isInitializingOnlineRoles = false;
  }

  // 初始化角色信息
  initRoles() {
    // 确保本地角色存储已初始化
    if (!uni.getStorageSync('allRoles')) {
      uni.setStorageSync('allRoles', []);
    }
    
    // 首次启动时，尝试从线上获取角色
    this.initializeOnlineRoles();
    
    // 定期清理无效的线上角色（每天一次）
    this.scheduleCleanInvalidOnlineRoles();
  }

  // 从线上初始化角色
  async initializeOnlineRoles() {
    // 如果已经初始化过，则不再重复获取
    if (this.hasInitializedOnlineRoles) {
      console.log('[角色管理] 已经初始化过线上角色，跳过');
      return;
    }
    
    // 如果正在初始化中，则不再重复调用
    if (this.isInitializingOnlineRoles) {
      console.log('[角色管理] 角色正在初始化中，跳过重复调用');
      return;
    }
    
    // 标记为正在初始化
    this.isInitializingOnlineRoles = true;
    
    try {
      console.log('[角色管理] 开始从线上获取角色');
      
      // 获取线上角色
      const result = await roleService.getAllRoles();
      
      if (result.errCode === 0) {
        const onlineRoles = result.data || [];
        console.log(`[角色管理] 获取线上角色成功，数量: ${onlineRoles.length}`);
        
        // 处理线上角色，添加isOnline标记
        const processedOnlineRoles = onlineRoles.map(role => {
          // 确保角色有id字段
          const id = role.id || ('online_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9));
          
          return {
            ...role,
            id: id,
            isOnline: true,
            _id: undefined
          };
        });
        
        // 获取本地角色
        const localRoles = this.getLocalRoles();
        console.log(`[角色管理] 获取本地角色成功，数量: ${localRoles.length}`);
        
        // 创建线上角色ID集合，用于快速查找
        const onlineRoleIds = new Set(processedOnlineRoles.map(role => role.id));
        
        // 检查本地标记为isOnline的角色是否在线上存在
        const invalidOnlineRoles = localRoles.filter(role => 
          role.isOnline && !onlineRoleIds.has(role.id)
        );
        
        if (invalidOnlineRoles.length > 0) {
          console.log(`[角色管理] 发现 ${invalidOnlineRoles.length} 个无效的线上角色，将被剔除`);
          invalidOnlineRoles.forEach(role => {
            console.log(`[角色管理] 剔除无效线上角色: ID=${role.id}, 名称=${role.name}`);
          });
        }
        
        // 合并角色列表，使用Map去重，优先保留线上角色
        const mergedRolesMap = new Map();
        
        // 先添加本地角色（排除无效的线上角色）
        localRoles.forEach(role => {
          // 如果是标记为线上角色但在线上找不到，则跳过
          if (role.isOnline && !onlineRoleIds.has(role.id)) {
            return;
          }
          mergedRolesMap.set(role.id, role);
        });
        
        // 再添加线上角色（会覆盖同ID的本地角色）
        processedOnlineRoles.forEach(role => {
          mergedRolesMap.set(role.id, role);
        });
        
        // 转换回数组
        const mergedRoles = Array.from(mergedRolesMap.values());
        console.log(`[角色管理] 合并后的角色总数: ${mergedRoles.length}`);
        
        // 保存到本地存储
        uni.setStorageSync('allRoles', mergedRoles);
        
        // 标记已初始化
        this.hasInitializedOnlineRoles = true;
        
        console.log('[角色管理] 线上角色初始化完成');
      } else {
        console.error('[角色管理] 获取线上角色失败:', result.errMsg);
      }
    } catch (error) {
      console.error('[角色管理] 初始化线上角色异常:', error);
    } finally {
      // 完成初始化，无论成功失败都重置标记
      this.isInitializingOnlineRoles = false;
    }
  }

  // 获取所有角色
  async getAllRoles() {
    // 确保已从线上初始化过角色
    await this.initializeOnlineRoles();
    
    // 从本地获取所有角色
    const allRoles = this.getLocalRoles();
    
    return {
      errCode: 0,
      errMsg: '获取角色列表成功',
      data: allRoles
    };
  }

  // 获取所有本地角色
  getLocalRoles() {
    // 从本地存储获取所有角色
    const allRoles = uni.getStorageSync('allRoles') || [];
    
    // 合并默认角色（如果不在allRoles中）
    const defaultRoles = rolesData.roles.map(role => ({
      ...role,
      isDefault: true,
      isCustom: false,
      isOnline: false
    }));
    
    // 检查默认角色是否已存在于allRoles中
    const mergedRoles = [...allRoles];
    
    defaultRoles.forEach(defaultRole => {
      const exists = mergedRoles.some(role => role.id === defaultRole.id);
      if (!exists) {
        mergedRoles.push(defaultRole);
      }
    });
    
    return mergedRoles;
  }

  // 获取所有高级角色
  async getAdultRoles() {
    // 确保已从线上初始化过角色
    await this.initializeOnlineRoles();
    
    // 从本地获取所有角色并过滤出高级角色
    const allRoles = this.getLocalRoles();
    const adultRoles = allRoles.filter(role => role.isAdult);
    
    return {
      errCode: 0,
      errMsg: '获取高级角色列表成功',
      data: adultRoles
    };
  }

  // 获取所有非高级角色
  async getNonAdultRoles() {
    // 确保已从线上初始化过角色
    await this.initializeOnlineRoles();
    
    // 从本地获取所有角色并过滤出非高级角色
    const allRoles = this.getLocalRoles();
    const nonAdultRoles = allRoles.filter(role => !role.isAdult);
    
    return {
      errCode: 0,
      errMsg: '获取普通角色列表成功',
      data: nonAdultRoles
    };
  }

  // 根据ID获取角色
  async getRoleById(id) {
    if (!id) {
      console.error('[角色管理] 获取角色失败: ID为空');
      return {
        errCode: 'PARAM_IS_NULL',
        errMsg: '角色ID不能为空',
        data: null
      };
    }
    
    console.log(`[角色管理] 开始获取角色，ID: ${id}`);
    
    // 确保已从线上初始化过角色
    await this.initializeOnlineRoles();
    
    // 从本地获取角色
    const role = this.getLocalRoleById(id);
    
    if (role) {
      console.log(`[角色管理] 找到角色: ${role.name}`);
      return {
        errCode: 0,
        errMsg: '获取角色成功',
        data: role
      };
    }
    
    // 如果本地没有找到，返回错误
    console.error(`[角色管理] 未找到ID为 ${id} 的角色`);
    return {
      errCode: 'ROLE_NOT_FOUND',
      errMsg: '未找到该角色',
      data: null
    };
  }

  // 根据ID获取本地角色
  getLocalRoleById(id) {
    // 确保id类型一致性
    const searchId = String(id);
    console.log(`[角色管理] 查找本地角色ID: ${searchId}`);
    
    const allRoles = this.getLocalRoles();
    const role = allRoles.find(role => String(role.id) === searchId);
    
    if (role) {
      console.log(`[角色管理] 找到本地角色: ${role.name}, ID: ${role.id}`);
    } else {
      console.warn(`[角色管理] 警告：未找到ID为 ${searchId} 的本地角色`);
    }
    
    return role;
  }

  // 同步方法，用于兼容旧代码
  getRoleByIdSync(id) {
    // 确保id类型一致性
    const searchId = String(id);
    console.log(`[角色管理] 同步查找角色ID: ${searchId}`);
    
    // 直接从本地获取角色
    const role = this.getLocalRoleById(id);
    
    if (role) {
      console.log(`[角色管理] 同步获取本地角色成功: ID=${id}, 名称=${role.name}`);
      return role;
    } else {
      console.warn(`[角色管理] 同步获取角色失败: ID=${id}`);
      return null;
    }
  }

  // 同步方法，获取所有高级角色，用于兼容旧代码
  getAdultRolesSync() {
    console.log(`[角色管理] 同步获取高级角色`);
    
    // 直接从本地获取高级角色
    const allRoles = this.getLocalRoles();
    const adultRoles = allRoles.filter(role => role.isAdult);
    
    console.log(`[角色管理] 同步获取高级角色成功，数量: ${adultRoles.length}`);
    return adultRoles;
  }

  // 同步方法，获取所有非高级角色，用于兼容旧代码
  getNonAdultRolesSync() {
    console.log(`[角色管理] 同步获取普通角色`);
    
    // 直接从本地获取普通角色
    const allRoles = this.getLocalRoles();
    const nonAdultRoles = allRoles.filter(role => !role.isAdult);
    
    console.log(`[角色管理] 同步获取普通角色成功，数量: ${nonAdultRoles.length}`);
    return nonAdultRoles;
  }

  // 同步方法，获取所有角色，用于兼容旧代码
  getAllRolesSync() {
    console.log(`[角色管理] 同步获取所有角色`);
    
    // 直接从本地获取所有角色
    const allRoles = this.getLocalRoles();
    
    console.log(`[角色管理] 同步获取所有角色成功，数量: ${allRoles.length}`);
    return allRoles;
  }

  // 添加或更新角色
  async saveRole(role) {
    try {
      // 确保角色有必要的字段
      const completeRole = this.ensureRoleFields(role);
      
      // 如果是线上角色，尝试保存到线上
      if (role.isOnline) {
        let result;
        
        if (role.id) {
          // 更新现有角色
          result = await roleService.updateRole(completeRole);
        } else {
          // 添加新角色
          result = await roleService.addRole(completeRole);
        }
        
        if (result.errCode === 0) {
          console.log(`[角色管理] 保存线上角色成功: ${role.name}`);
          
          // 更新本地存储
          this.saveLocalRole({
            ...result.data,
            isOnline: true
          });
          
          return {
            errCode: 0,
            errMsg: role.id ? '更新角色成功' : '添加角色成功',
            data: result.data
          };
        } else {
          console.error(`[角色管理] 保存线上角色失败: ${result.errMsg}`);
        }
      }
      
      // 保存到本地
      const localRole = this.saveLocalRole({
        ...completeRole,
        isOnline: false
      });
      
      console.log(`[角色管理] 保存本地角色成功: ${localRole.name}`);
      
      return {
        errCode: 0,
        errMsg: '保存角色成功',
        data: localRole
      };
    } catch (error) {
      console.error(`[角色管理] 保存角色异常: ${error}`);
      
      // 发生异常时，尝试保存到本地
      try {
        const localRole = this.saveLocalRole({
          ...role,
          isOnline: false
        });
        
        console.log(`[角色管理] 回退到保存本地角色: ${localRole.name}`);
        
        return {
          errCode: 0,
          errMsg: '保存本地角色成功',
          data: localRole
        };
      } catch (localError) {
        console.error(`[角色管理] 保存本地角色也失败: ${localError}`);
        return {
          errCode: 'SAVE_ROLE_FAILED',
          errMsg: '保存角色失败：' + (error.message || '未知错误'),
          data: null
        };
      }
    }
  }

  // 添加角色
  async addRole(role) {
    // 确保没有id，表示新增
    const newRole = { ...role };
    delete newRole.id;
    
    return this.saveRole(newRole);
  }

  // 更新角色
  async updateRole(role) {
    // 确保有id，表示更新
    if (!role.id) {
      console.error('[角色管理] 更新角色失败: 缺少id');
      return {
        errCode: 'PARAM_ERROR',
        errMsg: '更新角色失败: 缺少角色ID',
        data: null
      };
    }
    
    return this.saveRole(role);
  }

  // 确保角色有所有必要的字段
  ensureRoleFields(role) {
    // 基本字段
    const defaultFields = {
      id: role.id || Date.now().toString() + '_' + Math.random().toString(36).substr(2, 9),
      name: role.name || '',
      description: role.description || '',
      avatar: role.avatar || '/static/avatars/default.png',
      prompt: role.prompt || '',
      greeting: role.greeting || '',
      isCustom: role.isCustom !== undefined ? role.isCustom : true,
      isDefault: role.isDefault !== undefined ? role.isDefault : false,
      isAdult: role.isAdult !== undefined ? role.isAdult : false,
      isOnline: role.isOnline !== undefined ? role.isOnline : false,
      model: role.model || ''
    };
    
    return defaultFields;
  }

  // 保存本地角色
  saveLocalRole(role) {
    // 确保角色有必要的字段
    const completeRole = this.ensureRoleFields(role);
    
    // 获取所有角色
    const allRoles = this.getLocalRoles();
    
    // 查找是否已存在该角色
    const index = allRoles.findIndex(r => r.id === completeRole.id);
    
    if (index !== -1) {
      // 更新现有角色
      allRoles[index] = completeRole;
    } else {
      // 添加新角色
      allRoles.push(completeRole);
    }
    
    // 保存回本地存储
    uni.setStorageSync('allRoles', allRoles);
    
    return completeRole;
  }

  // 删除角色
  async deleteRole(id) {
    try {
      // 获取角色信息
      const role = this.getLocalRoleById(id);
      
      if (!role) {
        console.error(`[角色管理] 删除角色失败: 未找到ID为 ${id} 的角色`);
        return {
          errCode: 'ROLE_NOT_FOUND',
          errMsg: '未找到该角色',
        };
      }
      
      // 如果是线上角色，尝试从线上删除
      if (role.isOnline) {
        const result = await roleService.deleteRole(id);
        
        if (result.errCode === 0) {
          console.log(`[角色管理] 删除线上角色成功: ID=${id}`);
        } else {
          console.error(`[角色管理] 删除线上角色失败: ${result.errMsg}`);
        }
      }
      
      // 从本地删除
      this.deleteLocalRole(id);
      
      return {
        errCode: 0,
        errMsg: '删除角色成功'
      };
    } catch (error) {
      console.error(`[角色管理] 删除角色异常: ID=${id}, 错误=${error}`);
      
      // 发生异常时，尝试从本地删除
      try {
        this.deleteLocalRole(id);
        console.log(`[角色管理] 回退到删除本地角色: ID=${id}`);
        
        return {
          errCode: 0,
          errMsg: '删除本地角色成功'
        };
      } catch (localError) {
        console.error(`[角色管理] 删除本地角色也失败: ID=${id}, 错误=${localError}`);
        return {
          errCode: 'DELETE_ROLE_FAILED',
          errMsg: '删除角色失败：' + (error.message || '未知错误')
        };
      }
    }
  }

  // 删除本地角色
  deleteLocalRole(id) {
    // 获取所有角色
    let allRoles = this.getLocalRoles();
    
    // 过滤掉要删除的角色
    allRoles = allRoles.filter(role => role.id !== id);
    
    // 保存回本地存储
    uni.setStorageSync('allRoles', allRoles);
    
    console.log(`[角色管理] 已从本地删除角色: ID=${id}`);
  }

  // 清理无效的线上角色
  async cleanInvalidOnlineRoles() {
    try {
      console.log('[角色管理] 开始清理无效的线上角色');
      
      // 获取线上角色
      const result = await roleService.getAllRoles();
      
      if (result.errCode === 0) {
        const onlineRoles = result.data || [];
        console.log(`[角色管理] 获取线上角色成功，数量: ${onlineRoles.length}`);
        
        // 创建线上角色ID集合，用于快速查找
        const onlineRoleIds = new Set(onlineRoles.map(role => role.id));
        
        // 获取本地角色
        const localRoles = this.getLocalRoles();
        
        // 找出本地标记为isOnline但在线上不存在的角色
        const invalidOnlineRoles = localRoles.filter(role => 
          role.isOnline && !onlineRoleIds.has(role.id)
        );
        
        if (invalidOnlineRoles.length === 0) {
          console.log('[角色管理] 未发现无效的线上角色');
          return {
            errCode: 0,
            errMsg: '未发现无效的线上角色',
            data: { cleaned: 0 }
          };
        }
        
        console.log(`[角色管理] 发现 ${invalidOnlineRoles.length} 个无效的线上角色，将被剔除`);
        
        // 记录被剔除的角色信息
        const cleanedRoles = invalidOnlineRoles.map(role => ({
          id: role.id,
          name: role.name
        }));
        
        // 从本地存储中剔除无效的线上角色
        const validRoles = localRoles.filter(role => 
          !(role.isOnline && !onlineRoleIds.has(role.id))
        );
        
        // 保存回本地存储
        uni.setStorageSync('allRoles', validRoles);
        
        console.log(`[角色管理] 已清理 ${invalidOnlineRoles.length} 个无效的线上角色`);
        
        return {
          errCode: 0,
          errMsg: `已清理 ${invalidOnlineRoles.length} 个无效的线上角色`,
          data: {
            cleaned: invalidOnlineRoles.length,
            roles: cleanedRoles
          }
        };
      } else {
        console.error('[角色管理] 获取线上角色失败:', result.errMsg);
        return {
          errCode: 'GET_ONLINE_ROLES_FAILED',
          errMsg: '获取线上角色失败: ' + result.errMsg
        };
      }
    } catch (error) {
      console.error('[角色管理] 清理无效线上角色异常:', error);
      return {
        errCode: 'CLEAN_ROLES_FAILED',
        errMsg: '清理无效线上角色失败: ' + (error.message || '未知错误')
      };
    }
  }

  // 定期清理无效的线上角色
  scheduleCleanInvalidOnlineRoles() {
    try {
      // 获取上次清理时间
      const lastCleanTime = uni.getStorageSync('LAST_CLEAN_ONLINE_ROLES_TIME');
      const now = Date.now();
      
      // 如果从未清理过或者距离上次清理已超过24小时，则进行清理
      if (!lastCleanTime || (now - lastCleanTime > 24 * 60 * 60 * 1000)) {
        console.log('[角色管理] 定期清理无效的线上角色');
        
        // 异步清理，不阻塞主流程
        this.cleanInvalidOnlineRoles().then(result => {
          if (result.errCode === 0) {
            // 更新清理时间
            uni.setStorageSync('LAST_CLEAN_ONLINE_ROLES_TIME', now);
            console.log('[角色管理] 定期清理完成，已更新清理时间');
          }
        }).catch(error => {
          console.error('[角色管理] 定期清理异常:', error);
        });
      } else {
        console.log('[角色管理] 距离上次清理时间不足24小时，跳过定期清理');
      }
    } catch (error) {
      console.error('[角色管理] 安排定期清理任务异常:', error);
    }
  }
}

// 导出单例
export default new RoleManager();